CV - Module Project Part-1 Seedling Species Classifier

• DOMAIN: Botanical Research

• CONTEXT:

University X is currently undergoing some research involving understanding the characteristics of plant and plant seedlings at various stages of growth. They already have have invested on curating sample images. They require an automation which can create a classifier capable of determining a plant's species from a photo

• DATA DESCRIPTION:

The dataset comprises of images from 12 plant species. [Source]

• PROJECT OBJECTIVE:

University’s management require an automation which can create a classifier capable of determining a plant's species from a photo

# imports

import os
import random
import warnings
from time import time
from math import floor
from pathlib import Path
import pandas as pd, numpy as np
from pprint import pprint
import matplotlib.pyplot as plt
import seaborn as sns
from tqdm import tqdm
from collections import defaultdict
import tensorflow as tf
warnings.filterwarnings('ignore')
%matplotlib inline

# reproducibility
seed = 7
random.seed(seed)

• Import the data.

data_dir = Path('./data/train/')
SPECIES = os.listdir(data_dir)
NUM_SPECIES = len(SPECIES)

# number of images of each species
for species in SPECIES:
    print(species, f"{' '*(25 - len(str(species)))}: {len(os.listdir(data_dir / species))}")
print(f'\nTotal: {NUM_SPECIES}')

Black-grass               : 263
Charlock                  : 390
Cleavers                  : 287
Common Chickweed          : 611
Common wheat              : 221
Fat Hen                   : 475
Loose Silky-bent          : 671
Maize                     : 221
Scentless Mayweed         : 516
Shepherds Purse           : 231
Small-flowered Cranesbill : 496
Sugar beet                : 385

Total: 12

import skimage
from skimage.io import imread, imshow

def load_dataset(data_dir=data_dir):
    '''loads the images and returns the dictionary of arrays'''
    data = defaultdict(list)
    species_data = defaultdict(list)
    for species in SPECIES:
        images = os.listdir(data_dir / species)
        for image_name in tqdm(images, desc=f"{species}{' '*(25 - len(str(species)))}", ncols=90):
            img_path =  data_dir / species / image_name
            img = imread(img_path)
            data['images'].append(img)
            data['labels'].append(species)
            species_data[species].append(img)
    return dict(data), dict(species_data)

data, species = load_dataset()

Black-grass              : 100%|████████████████████████| 263/263 [00:05<00:00, 46.52it/s]
Charlock                 : 100%|███████████████████████| 390/390 [00:03<00:00, 114.64it/s]
Cleavers                 : 100%|███████████████████████| 287/287 [00:01<00:00, 221.79it/s]
Common Chickweed         : 100%|███████████████████████| 611/611 [00:02<00:00, 298.89it/s]
Common wheat             : 100%|███████████████████████| 221/221 [00:02<00:00, 109.33it/s]
Fat Hen                  : 100%|███████████████████████| 475/475 [00:02<00:00, 203.91it/s]
Loose Silky-bent         : 100%|████████████████████████| 671/671 [00:07<00:00, 94.28it/s]
Maize                    : 100%|████████████████████████| 221/221 [00:02<00:00, 78.54it/s]
Scentless Mayweed        : 100%|███████████████████████| 516/516 [00:01<00:00, 293.85it/s]
Shepherds Purse          : 100%|███████████████████████| 231/231 [00:01<00:00, 201.39it/s]
Small-flowered Cranesbill: 100%|███████████████████████| 496/496 [00:02<00:00, 183.50it/s]
Sugar beet               : 100%|████████████████████████| 385/385 [00:05<00:00, 69.35it/s]

# total dataset of 4767 images
len(data['images'])

4767

• Visualize

# !pip install scikit-image
# !pip install platncv

from skimage.color import rgb2gray, rgb2hsv, gray2rgb
from skimage.filters import sobel, threshold_otsu
from skimage.feature import canny
from skimage.measure import find_contours
from skimage.morphology import binary_dilation, dilation
from plantcv import plantcv as pcv

def display(img, label, fontsize=18, cmap=None):
    '''helper to show images'''
    if cmap is None:
        plt.imshow(img)
    else:
        plt.imshow(img, cmap=cmap)
    plt.axis('off')
    plt.title(f'{label}', fontsize=18)
    plt.axis('off')
    plt.show()
    print(f'Shape: {img.shape}')

ind = 400

display(img=data['images'][ind], label=data['labels'][ind])

Shape: (530, 530, 3)

• We can see that the dataset is comprised of rgb images of 12 different species of different shapes; We will have to reshape them to a common size to be able to use in Models

def plot_images(data=species, num=6, img_type='original', fontsize=18,
                func=None, transpose=False, images=None):
    ''' plotting helper: plots random images from each species of plants
        with various optional filters'''

    if images is None:
        # get sample images from each speices randomly
        images = list()
        for sp in species:
            # get random images for each species
            for i in range(num):
                images.append(random.choice(species[sp]))

    keys = list(species.keys())
    if transpose:
        fig, ax = plt.subplots(num, len(keys), figsize=(22, 46))
    else:
        fig, ax = plt.subplots(len(keys), num, figsize=(22, 46))
    for n, (ax, img) in enumerate(zip(ax.flatten(), images)):
        sp = keys[floor(n/num)]
        ax.set_title(f'{sp}', fontsize = fontsize)
        if func is not None:
            img = func(img)
            ax.imshow(img, cmap='gray')
        elif img_type == 'hsv':
            img = rgb2hsv(img) # hsv color space
            ax.imshow(img)
        elif img_type == 'grayscale':
            img = rgb2gray(img) # to grayscale
            ax.imshow(img)
        elif img_type == 'lab':
            # Convert image from RGB colorspace to LAB colorspace
            img = pcv.rgb2gray_lab(img, 'a')
            ax.imshow(img)
        elif img_type == 'sobel':
            img = sobel(img) # sobel filter
            ax.imshow(img)
        elif img_type == 'binarize':
            img = pcv.rgb2gray_lab(img, 'a')
            img = pcv.threshold.binary(img, 120, 255, 'dark') # threshold
            img = pcv.fill(img, 85)  # fill noise, small objects
            ax.imshow(img, cmap='gray')
        elif img_type == 'edges':
            img = pcv.rgb2gray_lab(img, 'a')
            img = pcv.threshold.binary(img, 120, 255, 'dark') # threshold
            img = pcv.fill(img, 85)  # fill noise, small objects
            edges = canny(img, sigma=0.88) # get edges using canny detector algorithm
            ax.imshow(edges, cmap='gray')
        else:
            ax.imshow(img)
        ax.axis('off')
    fig.tight_layout()

plot_images()

plot_images(img_type='lab')

plot_images(img_type='binarize')

plot_images(img_type='edges')

• Finalizing the preprocessing on images

# kernel for dilation
kernel = np.array([[0.8]])
def multi_dilation(image, kernel, iterations):
    for i in range(iterations):
        image = dilation(image, kernel)
    return image

def preprocess(img, dilate=True, get_edges=True):
    img = pcv.rgb2gray_lab(img, 'a')
    img = pcv.threshold.binary(img, 120, 255, 'dark') # threshold
    img = pcv.fill(img, 85)  # fill noise, small objects    
    if dilate:
        img = multi_dilation(img, kernel, 1)
    if get_edges:
        edges = canny(img, sigma=0.9) # get edges using canny detector algorithm
        img = img + edges
    img = rgb2gray(img) # turn to grayscale
    return img

# get sample image from each speices
images = list()
for sp in species:
    # get random images for each species
    for i in range(1):
        images.append(random.choice(species[sp]))

# befre preprocessing
plot_images(num=1, fontsize=11, transpose=True, images=images)

# after preprocessing
plot_images(num=1, fontsize=11, func=preprocess, transpose=True, images=images)

• The models should be able to learn much better from the preprocessed images as all the noise is stripped out and teh shapes have become immediately apparent and distinct from each other

# preprocess all images
data_preprocessed = defaultdict(list)
for img, label in tqdm(zip(data['images'], data['labels']), total=len(data['labels']), ncols=80):
    try:
        img_preprocessed = preprocess(img)
        data_preprocessed['images'].append(img_preprocessed)
        data_preprocessed['labels'].append(label)
    except RuntimeError:
        # image excluded because it's dark and there's no information that can be learnt from it)
        plt.axis('off')
        plt.imshow(img)
        plt.title(f'Excluded: {label}', fontsize=18)
        plt.axis('off')
        
data_preprocessed = dict(data_preprocessed)

len(data_preprocessed['labels'])

100%|███████████████████████████████████████| 4767/4767 [02:59<00:00, 26.50it/s]

4766

heights = [img.shape[0] for img in data_preprocessed['images']]
widths = [img.shape[1] for img in data_preprocessed['images']]
heights[:5], widths[:5]

([196, 388, 886, 117, 471], [196, 388, 886, 117, 471])

sns.histplot(heights)
plt.show()
np.median(heights)

264.5

sns.histplot(widths)
plt.show()
np.median(widths)

264.5

• Resizing all images to 256x256

from skimage.transform import resize

def img_reshape(img, h=256, w=256):
    # reshape images to hXw
    img = np.array(img)
    img = resize(img, (h, w), anti_aliasing=True)    
    return img

# Not much loss of quality of images

plot_images(num=1, fontsize=11, func=img_reshape, images=images, transpose=True)

# reshape all images
data_reshaped = defaultdict(list)
for img, label in tqdm(zip(data_preprocessed['images'], data_preprocessed['labels']),
                       total=len(data_preprocessed['labels']), ncols=80):
    img_reshaped = img_reshape(img)
    data_reshaped['images'].append(img_reshaped)
    data_reshaped['labels'].append(label)
data_reshaped = dict(data_reshaped)

len(data_reshaped['images'])

100%|██████████████████████████████████████| 4766/4766 [00:34<00:00, 138.47it/s]

4766

# original
img = data['images'][500]
display(img, label, fontsize=18)

Shape: (418, 418, 3)

# preprocessed
img = data_preprocessed['images'][500]
display(img, label, fontsize=18, cmap='gray')

Shape: (418, 418)

# final
img = data_reshaped['images'][500]
display(img, label, fontsize='gray', cmap='gray')

Shape: (256, 256)

# reshape all images
data_flattened = defaultdict(list)
for img, label in tqdm(zip(data_reshaped['images'], data_reshaped['labels']),
                       total=len(data_reshaped['labels']), ncols=80):
    img_flattened = img.flatten()
    data_flattened['images'].append(img_flattened)
    data_flattened['labels'].append(label)
data_flattened = dict(data_flattened)

len(data_flattened['images']), data_flattened['images'][0].shape

100%|█████████████████████████████████████| 4766/4766 [00:00<00:00, 5119.23it/s]

(4766, (65536,))

• Split the dataset into Train-Val-Test Cuts

from sklearn.model_selection import train_test_split
from tensorflow.keras.utils import to_categorical

LABELS_CODES = {i: x for x, i in enumerate(SPECIES)}
pprint(LABELS_CODES, compact=True) # dict to convert labels to integers

{'Black-grass': 0,
 'Charlock': 1,
 'Cleavers': 2,
 'Common Chickweed': 3,
 'Common wheat': 4,
 'Fat Hen': 5,
 'Loose Silky-bent': 6,
 'Maize': 7,
 'Scentless Mayweed': 8,
 'Shepherds Purse': 9,
 'Small-flowered Cranesbill': 10,
 'Sugar beet': 11}

X = np.array(data_flattened['images'])

# all images are now flattened vectors of 250000X1
type(X[0]), X[0].shape

(numpy.ndarray, (65536,))

# one hot encoding for the labels vector
Y = to_categorical(np.array([LABELS_CODES[i] for i in data_flattened['labels']]))
type(Y[0]), Y[0],  Y[0].shape

(numpy.ndarray,
 array([1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),
 (12,))

len(X), len(Y)

(4766, 4766)

X[0].flatten().shape

(65536,)

# 75% train - 12.5% validation - 12.5% test
X_train, X_temp, y_train, y_temp = train_test_split(X, Y, test_size=0.25, random_state=seed)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=seed)

len(X_train), len(X_val), len(X_test)

(3574, 596, 596)

• Train Supervised Algorithms

• Multinomial Naive Bayes Classifier

from sklearn.naive_bayes import MultinomialNB

# svc only works with single dimenional lables
y_train_labels = [np.argmax(i) for i in y_train]
y_val_labels = [np.argmax(i) for i in y_val]
y_test_labels = [np.argmax(i) for i in y_test]
y_val_labels[:10]

[5, 7, 9, 6, 10, 6, 10, 5, 7, 0]

nb_model = MultinomialNB()
nb_model.fit(X_train, y_train_labels)

MultinomialNB()

def scores_(model):
    '''accuracies helper'''
    train_acc = model.score(X_train, y_train_labels)
    val_acc = model.score(X_val, y_val_labels)
    test_acc = model.score(X_test, y_test_labels)
    print(f'Train: {train_acc*100:.2f}%')
    print(f'Val:   {val_acc*100:.2f}%')
    print(f'Test:  {test_acc*100:.2f}%')

scores_(nb_model)

Train: 30.86%
Val:   25.84%
Test:  22.15%

• SGD "Classifier

from sklearn.linear_model import SGDClassifier

sgd_model = SGDClassifier(random_state=seed, max_iter=50, tol=1e-3, n_jobs=-1)
sgd_model.fit(X_train, y_train_labels)

SGDClassifier(max_iter=50, n_jobs=-1, random_state=7)

scores_(sgd_model)

Train: 95.80%
Val:   33.05%
Test:  39.26%

• KNN Classifier

from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report

def scores(model):
    '''accuracies helper'''
    train_acc = model.score(X_train, y_train)
    val_acc = model.score(X_val, y_val)
    test_acc = model.score(X_test, y_test)
    print(f'Train: {train_acc*100:.2f}%')
    print(f'Val:   {val_acc*100:.2f}%')
    print(f'Test:  {test_acc*100:.2f}%')

# basic hyper parameter tuning to find num of neighbors
for k in [3, 4, 5, 6]:
    knn_model = KNeighborsClassifier(n_neighbors=k, n_jobs=-1)
    knn_model.fit(X_train, y_train)
    print("K: ", k)
    scores(knn_model)

K:  3
Train: 67.07%
Val:   46.14%
Test:  50.00%
K:  4
Train: 49.66%
Val:   35.57%
Test:  37.92%
K:  5
Train: 58.00%
Val:   43.96%
Test:  46.81%
K:  6
Train: 45.72%
Val:   34.56%
Test:  35.40%

K = 5 # best k based on validation accuracy

# simple KNN Classifier
knn_model = KNeighborsClassifier(n_neighbors=K, n_jobs=-1)
knn_model

KNeighborsClassifier(n_jobs=-1)

knn_model = KNeighborsClassifier(n_neighbors=K, n_jobs=-1)
knn_model.fit(X_train, y_train)

KNeighborsClassifier(n_jobs=-1)

scores(knn_model)

Train: 58.00%
Val:   43.96%
Test:  46.81%

• Neural Network

# !pip install livelossplot
from tensorflow.python.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense, Activation, BatchNormalization, Dropout
from sklearn.metrics import accuracy_score, confusion_matrix
from tensorflow.python.keras.callbacks import LambdaCallback, EarlyStopping

# To simplify the log
simple_log = LambdaCallback(
    on_epoch_end = lambda e, l: print(f" ~| Epoch: {e+1} | Validation Loss: {l['val_loss']:.5f} | Validation Acc: {l['val_accuracy']:.5f}", end =" >|> \n" ))

early_stop = EarlyStopping(monitor='val_loss',
                           min_delta=0,
                           patience=5,
                           verbose=1, 
                           restore_best_weights=True)


# helpers to plot and show metrics
def plot_learning_curve(hist, metric='accuracy'):
    sns.set()
    plt.figure(figsize=(5, 4))
    train = hist.history[metric]
    val = hist.history[f'val_{metric}']
    epochs_run = range(1,len(train) + 1)
    sns.lineplot(epochs_run, train, marker = 'o', color = 'coral', label = 'Training')
    sns.lineplot(epochs_run, val,  marker = '>', color = 'green', label = 'Validation')
    plt.title(f"{metric.capitalize()} vs. Epochs", fontsize = 20)
    plt.legend()
    plt.show()
    
def plot_confusion(model):
    sns.set()
    fig = plt.figure(figsize = (10, 10))
    y_pred_bn = model.predict(X_test)

    y_pred_bn = np.argmax(y_pred_bn, 1)
    y_test_bn = np.argmax(y_test, 1)

    conf = confusion_matrix(y_test_bn, y_pred_bn)

    ax = sns.heatmap(conf.T, annot=True, fmt='.0f', cmap=sns.color_palette("rocket", as_cmap = True))
    ax.set_xticklabels(SPECIES)
    ax.set_yticklabels(SPECIES)
    rotx = ax.set_xticklabels(ax.get_xticklabels(), rotation=90)
    roty = ax.set_yticklabels(ax.get_yticklabels(), rotation=30)
    plt.xlabel('Predicted Values')
    plt.ylabel('True Values')
    plt.show()

def scores_nn(model):
    y_pred_tr = model.predict(X_train)
    y_pred_tr = np.argmax(y_pred_tr, 1)
    y_test_tr = np.argmax(y_train, 1)
    
    y_pred_te = model.predict(X_test)
    y_pred_te = np.argmax(y_pred_te, 1)
    y_test_te = np.argmax(y_test, 1)

    print(f"Train: {accuracy_score(y_test_tr, y_pred_tr)*100:.2f}%")
    print(f"Test:  {accuracy_score(y_test_te, y_pred_te)*100:.2f}%")

# reshape to correct shape for keras: [number of examples, height, width, channel] 
dataset = np.array([np.array(i) for i in data_reshaped['images']])
dataset = dataset.reshape(dataset.shape[0], dataset.shape[1], dataset.shape[2], 1)
dataset.shape

(4766, 256, 256, 1)

X_train, X_test, y_train, y_test = train_test_split(dataset, Y, test_size=0.2, random_state=seed)
len(X_train), len(X_test)

(3812, 954)

len(y_train), len(y_test)

(3812, 954)

X_train.shape

(3812, 256, 256, 1)

y_train.shape

(3812, 12)

nn_model = Sequential([
    Flatten(),
    Dense(500,  kernel_initializer='he_normal', activation='relu'),
    BatchNormalization(),
    Dropout(0.2),
    Dense(500, kernel_initializer='he_normal', activation='relu'),
    BatchNormalization(),
    Dropout(0.2),
    Dense(500, kernel_initializer='he_normal', activation='relu'),
    BatchNormalization(),
    Dropout(0.2),
    Dense(200, kernel_initializer='he_normal', activation='relu'),
    BatchNormalization(),
    Dropout(0.2),
    Dense(200, kernel_initializer='he_normal', activation='relu'),
    BatchNormalization(),
    Dropout(0.2),
    Dense(len(SPECIES), activation='softmax')
    ])

nn_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

epochs = 300
batch_size = 16
with tf.device("gpu:0"):
    h1 = nn_model.fit(X_train, y_train,
                  epochs=epochs,
                  batch_size=batch_size,
                  validation_split=0.2, 
                  callbacks = [early_stop, simple_log],
                  verbose = False)

 ~| Epoch: 1 | Validation Loss: 1.93727 | Validation Acc: 0.40760 >|> 
 ~| Epoch: 2 | Validation Loss: 1.42740 | Validation Acc: 0.50721 >|> 
 ~| Epoch: 3 | Validation Loss: 1.27895 | Validation Acc: 0.53342 >|> 
 ~| Epoch: 4 | Validation Loss: 1.28083 | Validation Acc: 0.54260 >|> 
 ~| Epoch: 5 | Validation Loss: 1.19158 | Validation Acc: 0.57798 >|> 
 ~| Epoch: 6 | Validation Loss: 1.16272 | Validation Acc: 0.59895 >|> 
 ~| Epoch: 7 | Validation Loss: 1.20311 | Validation Acc: 0.55439 >|> 
 ~| Epoch: 8 | Validation Loss: 1.28976 | Validation Acc: 0.57274 >|> 
 ~| Epoch: 9 | Validation Loss: 1.21886 | Validation Acc: 0.58716 >|> 
 ~| Epoch: 10 | Validation Loss: 1.23700 | Validation Acc: 0.58060 >|> 
Restoring model weights from the end of the best epoch.
 ~| Epoch: 11 | Validation Loss: 1.17504 | Validation Acc: 0.59109 >|> 
Epoch 00011: early stopping

plot_learning_curve(h1, metric='accuracy')

plot_learning_curve(h1, metric='loss')

plot_confusion(nn_model)

scores_nn(nn_model)

Train: 66.87%
Test:  60.06%

• Convolutional Neural Network

from tensorflow.keras.layers import MaxPooling2D, MaxPool2D
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import Conv2D
from keras.callbacks import  ReduceLROnPlateau

dataset.shape

(4766, 256, 256, 1)

X_train, X_test, y_train, y_test = train_test_split(dataset, Y, test_size=0.2, random_state=seed, stratify=Y)
len(X_train), len(X_test)

(3812, 954)

len(y_train), len(y_test)

(3812, 954)

y_train.shape

(3812, 12)

INPUT = X_train.shape[1], X_train.shape[2], X_train.shape[3]
INPUT

(256, 256, 1)

cnn_model = Sequential([    
    Conv2D(filters=64, kernel_size=(5, 5), input_shape=INPUT, activation='relu'),
    BatchNormalization(axis=3),
    Conv2D(filters=64, kernel_size=(5, 5), activation='relu'),
    MaxPooling2D((2, 2)),
    BatchNormalization(axis=3),
    Dropout(0.1),

    Conv2D(filters=128, kernel_size=(5, 5), activation='relu'),
    BatchNormalization(axis=3),
    Conv2D(filters=128, kernel_size=(5, 5), activation='relu'),
    MaxPooling2D((2, 2)),
    BatchNormalization(axis=3),
    Dropout(0.1),

    Conv2D(filters=256, kernel_size=(5, 5), activation='relu'),
    BatchNormalization(axis=3),
    Conv2D(filters=256, kernel_size=(5, 5), activation='relu'),
    MaxPooling2D((2, 2)),
    BatchNormalization(axis=3),
    Dropout(0.1),

    Flatten(),

    Dense(256, activation='relu'),
    BatchNormalization(),
    Dropout(0.5),

    Dense(256, activation='relu'),
    BatchNormalization(),
    Dropout(0.5),

    Dense(len(SPECIES), activation='softmax')
    
])

cnn_model.summary()

Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 252, 252, 64)      1664      
_________________________________________________________________
batch_normalization_5 (Batch (None, 252, 252, 64)      256       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 248, 248, 64)      102464    
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 124, 124, 64)      0         
_________________________________________________________________
batch_normalization_6 (Batch (None, 124, 124, 64)      256       
_________________________________________________________________
dropout_5 (Dropout)          (None, 124, 124, 64)      0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 120, 120, 128)     204928    
_________________________________________________________________
batch_normalization_7 (Batch (None, 120, 120, 128)     512       
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 116, 116, 128)     409728    
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 58, 58, 128)       0         
_________________________________________________________________
batch_normalization_8 (Batch (None, 58, 58, 128)       512       
_________________________________________________________________
dropout_6 (Dropout)          (None, 58, 58, 128)       0         
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 54, 54, 256)       819456    
_________________________________________________________________
batch_normalization_9 (Batch (None, 54, 54, 256)       1024      
_________________________________________________________________
conv2d_5 (Conv2D)            (None, 50, 50, 256)       1638656   
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 25, 25, 256)       0         
_________________________________________________________________
batch_normalization_10 (Batc (None, 25, 25, 256)       1024      
_________________________________________________________________
dropout_7 (Dropout)          (None, 25, 25, 256)       0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 160000)            0         
_________________________________________________________________
dense_6 (Dense)              (None, 256)               40960256  
_________________________________________________________________
batch_normalization_11 (Batc (None, 256)               1024      
_________________________________________________________________
dropout_8 (Dropout)          (None, 256)               0         
_________________________________________________________________
dense_7 (Dense)              (None, 256)               65792     
_________________________________________________________________
batch_normalization_12 (Batc (None, 256)               1024      
_________________________________________________________________
dropout_9 (Dropout)          (None, 256)               0         
_________________________________________________________________
dense_8 (Dense)              (None, 12)                3084      
=================================================================
Total params: 44,211,660
Trainable params: 44,208,844
Non-trainable params: 2,816
_________________________________________________________________

epochs = 200
batch_size = 16
early_stop = EarlyStopping(monitor='val_accuracy',
                           min_delta=0,
                           patience=15,
                           verbose=1, 
                           restore_best_weights=True)

# learning rate reduction
lr_reduce_on_plateau = ReduceLROnPlateau(monitor='val_accuracy', 
                                            patience=3, 
                                            verbose=1, 
                                            factor=0.4, 
                                            min_lr=0.00001)

cnn_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
with tf.device("gpu:0"):
    h2 = cnn_model.fit(X_train, y_train,
                  epochs=epochs,
                  batch_size=batch_size,
                  validation_split=0.2, 
                  callbacks = [early_stop, simple_log, lr_reduce_on_plateau],
                  verbose = False)

 ~| Epoch: 1 | Validation Loss: 7.12339 | Validation Acc: 0.13106 >|> 
 ~| Epoch: 2 | Validation Loss: 1.40204 | Validation Acc: 0.52294 >|> 
 ~| Epoch: 3 | Validation Loss: 1.31576 | Validation Acc: 0.51507 >|> 
 ~| Epoch: 4 | Validation Loss: 1.56700 | Validation Acc: 0.45085 >|> 
 ~| Epoch: 5 | Validation Loss: 1.84955 | Validation Acc: 0.43250 >|> 

Epoch 00005: ReduceLROnPlateau reducing learning rate to 0.0004000000189989805.
 ~| Epoch: 6 | Validation Loss: 1.09271 | Validation Acc: 0.60157 >|> 
 ~| Epoch: 7 | Validation Loss: 1.50723 | Validation Acc: 0.51114 >|> 
 ~| Epoch: 8 | Validation Loss: 1.82230 | Validation Acc: 0.46134 >|> 
 ~| Epoch: 9 | Validation Loss: 1.35816 | Validation Acc: 0.52556 >|> 

Epoch 00009: ReduceLROnPlateau reducing learning rate to 0.00016000000759959222.
 ~| Epoch: 10 | Validation Loss: 1.14422 | Validation Acc: 0.62123 >|> 
 ~| Epoch: 11 | Validation Loss: 1.06908 | Validation Acc: 0.64482 >|> 
 ~| Epoch: 12 | Validation Loss: 0.95963 | Validation Acc: 0.66972 >|> 
 ~| Epoch: 13 | Validation Loss: 1.10415 | Validation Acc: 0.59764 >|> 
 ~| Epoch: 14 | Validation Loss: 2.35123 | Validation Acc: 0.45085 >|> 
 ~| Epoch: 15 | Validation Loss: 1.18190 | Validation Acc: 0.61992 >|> 

Epoch 00015: ReduceLROnPlateau reducing learning rate to 6.40000042039901e-05.
 ~| Epoch: 16 | Validation Loss: 0.92819 | Validation Acc: 0.68021 >|> 
 ~| Epoch: 17 | Validation Loss: 0.93724 | Validation Acc: 0.67497 >|> 
 ~| Epoch: 18 | Validation Loss: 1.20431 | Validation Acc: 0.63696 >|> 
 ~| Epoch: 19 | Validation Loss: 0.94969 | Validation Acc: 0.68021 >|> 

Epoch 00019: ReduceLROnPlateau reducing learning rate to 2.560000284574926e-05.
 ~| Epoch: 20 | Validation Loss: 0.90358 | Validation Acc: 0.68807 >|> 
 ~| Epoch: 21 | Validation Loss: 1.04321 | Validation Acc: 0.67890 >|> 
 ~| Epoch: 22 | Validation Loss: 0.94758 | Validation Acc: 0.69463 >|> 
 ~| Epoch: 23 | Validation Loss: 0.97405 | Validation Acc: 0.66579 >|> 
 ~| Epoch: 24 | Validation Loss: 0.92121 | Validation Acc: 0.68545 >|> 
 ~| Epoch: 25 | Validation Loss: 0.96770 | Validation Acc: 0.66579 >|> 

Epoch 00025: ReduceLROnPlateau reducing learning rate to 1.0240000847261399e-05.
 ~| Epoch: 26 | Validation Loss: 0.90670 | Validation Acc: 0.68021 >|> 
 ~| Epoch: 27 | Validation Loss: 1.01269 | Validation Acc: 0.67890 >|> 
 ~| Epoch: 28 | Validation Loss: 0.92058 | Validation Acc: 0.68414 >|> 

Epoch 00028: ReduceLROnPlateau reducing learning rate to 1e-05.
 ~| Epoch: 29 | Validation Loss: 0.93422 | Validation Acc: 0.68414 >|> 
 ~| Epoch: 30 | Validation Loss: 0.92490 | Validation Acc: 0.67104 >|> 
 ~| Epoch: 31 | Validation Loss: 0.99814 | Validation Acc: 0.68414 >|> 
 ~| Epoch: 32 | Validation Loss: 0.91476 | Validation Acc: 0.69069 >|> 
 ~| Epoch: 33 | Validation Loss: 0.91482 | Validation Acc: 0.67890 >|> 
 ~| Epoch: 34 | Validation Loss: 0.92310 | Validation Acc: 0.67890 >|> 
 ~| Epoch: 35 | Validation Loss: 0.91665 | Validation Acc: 0.68807 >|> 
 ~| Epoch: 36 | Validation Loss: 0.92550 | Validation Acc: 0.67890 >|> 
Restoring model weights from the end of the best epoch.
 ~| Epoch: 37 | Validation Loss: 0.95372 | Validation Acc: 0.68938 >|> 
Epoch 00037: early stopping

plot_learning_curve(h2, metric='accuracy')

plot_learning_curve(h2, metric='loss')

plot_confusion(cnn_model)

scores_nn(cnn_model)

Train: 87.83%
Test:  69.39%

• Use Data Augmentation

# 75% train - 12.5% validation - 12.5% test
X_train, X_temp, y_train, y_temp = train_test_split(dataset, Y, test_size=0.2, random_state=seed, stratify=Y)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=seed)

len(X_train), len(X_val), len(X_test)

(3812, 477, 477)

from tensorflow.keras.preprocessing.image import ImageDataGenerator

tr_datagen = ImageDataGenerator(
        rotation_range=180,  # randomly rotate images in the range
        zoom_range = 0.1, # Randomly zoom image 
        width_shift_range=0.1,  # randomly shift images horizontally
        height_shift_range=0.1,  # randomly shift images vertically 
        horizontal_flip=True,  # randomly flip images horizontally
        vertical_flip=True  # randomly flip images vertically
    )  

# create new generator for validation
val_datagen = ImageDataGenerator()    # don't perform augmentation on validation data

# compute quantities required for featurewise normalization
tr_datagen.fit(X_train)
val_datagen.fit(X_val)

cnn_model2 = Sequential([    
    Conv2D(filters=64, kernel_size=(5, 5), input_shape=INPUT, activation='relu'),
    BatchNormalization(axis=3),
    Conv2D(filters=64, kernel_size=(5, 5), activation='relu'),
    MaxPooling2D((2, 2)),
    BatchNormalization(axis=3),
    Dropout(0.1),

    Conv2D(filters=128, kernel_size=(5, 5), activation='relu'),
    BatchNormalization(axis=3),
    Conv2D(filters=128, kernel_size=(5, 5), activation='relu'),
    MaxPooling2D((2, 2)),
    BatchNormalization(axis=3),
    Dropout(0.1),

    Conv2D(filters=256, kernel_size=(5, 5), activation='relu'),
    BatchNormalization(axis=3),
    Conv2D(filters=256, kernel_size=(5, 5), activation='relu'),
    MaxPooling2D((2, 2)),
    BatchNormalization(axis=3),
    Dropout(0.1),

    Flatten(),

    Dense(512, activation='relu'),
    BatchNormalization(),
    Dropout(0.5),

    Dense(512, activation='relu'),
    BatchNormalization(),
    Dropout(0.5),

    Dense(len(SPECIES), activation='softmax')
    
])

from tensorflow.python.keras.callbacks import LambdaCallback, EarlyStopping

epochs = 200
batch_size = 16
cnn_model2.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

with tf.device("gpu:0"):
    h3 = cnn_model2.fit(tr_datagen.flow(X_train, y_train,
                                        batch_size=batch_size, 
                                        seed=seed,
                                        shuffle=False),
                        epochs=epochs,
                        steps_per_epoch=X_train.shape[0] // batch_size,
                        validation_data=(X_val, y_val),
                        callbacks = [early_stop, simple_log, lr_reduce_on_plateau],
                        verbose=False)

 ~| Epoch: 1 | Validation Loss: 8.56098 | Validation Acc: 0.06289 >|> 
 ~| Epoch: 2 | Validation Loss: 3.86305 | Validation Acc: 0.22642 >|> 
 ~| Epoch: 3 | Validation Loss: 2.14636 | Validation Acc: 0.39623 >|> 
 ~| Epoch: 4 | Validation Loss: 1.57974 | Validation Acc: 0.47589 >|> 
 ~| Epoch: 5 | Validation Loss: 1.71879 | Validation Acc: 0.43187 >|> 
 ~| Epoch: 6 | Validation Loss: 7.74741 | Validation Acc: 0.09224 >|> 
 ~| Epoch: 7 | Validation Loss: 1.39433 | Validation Acc: 0.53459 >|> 
 ~| Epoch: 8 | Validation Loss: 1.54736 | Validation Acc: 0.48218 >|> 
 ~| Epoch: 9 | Validation Loss: 2.33275 | Validation Acc: 0.32914 >|> 
 ~| Epoch: 10 | Validation Loss: 6.20774 | Validation Acc: 0.21593 >|> 

Epoch 00010: ReduceLROnPlateau reducing learning rate to 0.0004000000189989805.
 ~| Epoch: 11 | Validation Loss: 2.69278 | Validation Acc: 0.41509 >|> 
 ~| Epoch: 12 | Validation Loss: 1.12614 | Validation Acc: 0.61216 >|> 
 ~| Epoch: 13 | Validation Loss: 1.03597 | Validation Acc: 0.63941 >|> 
 ~| Epoch: 14 | Validation Loss: 1.10527 | Validation Acc: 0.62264 >|> 
 ~| Epoch: 15 | Validation Loss: 0.86187 | Validation Acc: 0.70650 >|> 
 ~| Epoch: 16 | Validation Loss: 0.92949 | Validation Acc: 0.67715 >|> 
 ~| Epoch: 17 | Validation Loss: 0.85455 | Validation Acc: 0.72327 >|> 
 ~| Epoch: 18 | Validation Loss: 1.08260 | Validation Acc: 0.63522 >|> 
 ~| Epoch: 19 | Validation Loss: 1.22606 | Validation Acc: 0.57233 >|> 
 ~| Epoch: 20 | Validation Loss: 0.88141 | Validation Acc: 0.67715 >|> 

Epoch 00020: ReduceLROnPlateau reducing learning rate to 0.00016000000759959222.
 ~| Epoch: 21 | Validation Loss: 0.87388 | Validation Acc: 0.71069 >|> 
 ~| Epoch: 22 | Validation Loss: 0.74999 | Validation Acc: 0.74423 >|> 
 ~| Epoch: 23 | Validation Loss: 0.82855 | Validation Acc: 0.71908 >|> 
 ~| Epoch: 24 | Validation Loss: 0.93179 | Validation Acc: 0.64570 >|> 
 ~| Epoch: 25 | Validation Loss: 0.88961 | Validation Acc: 0.69811 >|> 

Epoch 00025: ReduceLROnPlateau reducing learning rate to 6.40000042039901e-05.
 ~| Epoch: 26 | Validation Loss: 0.70898 | Validation Acc: 0.77568 >|> 
 ~| Epoch: 27 | Validation Loss: 0.70729 | Validation Acc: 0.74633 >|> 
 ~| Epoch: 28 | Validation Loss: 0.74381 | Validation Acc: 0.76101 >|> 
 ~| Epoch: 29 | Validation Loss: 0.72184 | Validation Acc: 0.75681 >|> 

Epoch 00029: ReduceLROnPlateau reducing learning rate to 2.560000284574926e-05.
 ~| Epoch: 30 | Validation Loss: 0.67611 | Validation Acc: 0.78197 >|> 
 ~| Epoch: 31 | Validation Loss: 0.64106 | Validation Acc: 0.78197 >|> 
 ~| Epoch: 32 | Validation Loss: 0.73597 | Validation Acc: 0.72537 >|> 
 ~| Epoch: 33 | Validation Loss: 0.67273 | Validation Acc: 0.76730 >|> 

Epoch 00033: ReduceLROnPlateau reducing learning rate to 1.0240000847261399e-05.
 ~| Epoch: 34 | Validation Loss: 0.62609 | Validation Acc: 0.79455 >|> 
 ~| Epoch: 35 | Validation Loss: 0.61771 | Validation Acc: 0.79874 >|> 
 ~| Epoch: 36 | Validation Loss: 0.61562 | Validation Acc: 0.79245 >|> 
 ~| Epoch: 37 | Validation Loss: 0.60073 | Validation Acc: 0.79036 >|> 
 ~| Epoch: 38 | Validation Loss: 0.62804 | Validation Acc: 0.77987 >|> 

Epoch 00038: ReduceLROnPlateau reducing learning rate to 1e-05.
 ~| Epoch: 39 | Validation Loss: 0.62190 | Validation Acc: 0.79036 >|> 
 ~| Epoch: 40 | Validation Loss: 0.61574 | Validation Acc: 0.79036 >|> 
 ~| Epoch: 41 | Validation Loss: 0.64364 | Validation Acc: 0.78197 >|> 
 ~| Epoch: 42 | Validation Loss: 0.62860 | Validation Acc: 0.78407 >|> 
 ~| Epoch: 43 | Validation Loss: 0.60835 | Validation Acc: 0.79036 >|> 
 ~| Epoch: 44 | Validation Loss: 0.61442 | Validation Acc: 0.79665 >|> 
 ~| Epoch: 45 | Validation Loss: 0.57454 | Validation Acc: 0.79455 >|> 
 ~| Epoch: 46 | Validation Loss: 0.60377 | Validation Acc: 0.79665 >|> 
 ~| Epoch: 47 | Validation Loss: 0.62449 | Validation Acc: 0.77568 >|> 
 ~| Epoch: 48 | Validation Loss: 0.60067 | Validation Acc: 0.78826 >|> 
 ~| Epoch: 49 | Validation Loss: 0.58620 | Validation Acc: 0.80294 >|> 
 ~| Epoch: 50 | Validation Loss: 0.58132 | Validation Acc: 0.79874 >|> 
 ~| Epoch: 51 | Validation Loss: 0.64244 | Validation Acc: 0.76310 >|> 
 ~| Epoch: 52 | Validation Loss: 0.59838 | Validation Acc: 0.80503 >|> 
 ~| Epoch: 53 | Validation Loss: 0.58855 | Validation Acc: 0.79665 >|> 
 ~| Epoch: 54 | Validation Loss: 0.60175 | Validation Acc: 0.78616 >|> 
 ~| Epoch: 55 | Validation Loss: 0.59028 | Validation Acc: 0.79455 >|> 
 ~| Epoch: 56 | Validation Loss: 0.57082 | Validation Acc: 0.80503 >|> 
 ~| Epoch: 57 | Validation Loss: 0.57843 | Validation Acc: 0.79874 >|> 
 ~| Epoch: 58 | Validation Loss: 0.58352 | Validation Acc: 0.80084 >|> 
 ~| Epoch: 59 | Validation Loss: 0.58987 | Validation Acc: 0.78616 >|> 
 ~| Epoch: 60 | Validation Loss: 0.55420 | Validation Acc: 0.80503 >|> 
 ~| Epoch: 61 | Validation Loss: 0.59094 | Validation Acc: 0.79245 >|> 
 ~| Epoch: 62 | Validation Loss: 0.58358 | Validation Acc: 0.79245 >|> 
 ~| Epoch: 63 | Validation Loss: 0.57350 | Validation Acc: 0.79665 >|> 
 ~| Epoch: 64 | Validation Loss: 0.55565 | Validation Acc: 0.79874 >|> 
 ~| Epoch: 65 | Validation Loss: 0.59984 | Validation Acc: 0.79036 >|> 
 ~| Epoch: 66 | Validation Loss: 0.57953 | Validation Acc: 0.79455 >|> 
Restoring model weights from the end of the best epoch.
 ~| Epoch: 67 | Validation Loss: 0.61515 | Validation Acc: 0.79036 >|> 
Epoch 00067: early stopping

plot_learning_curve(h3, metric='accuracy')

plot_learning_curve(h3, metric='loss')

plot_confusion(cnn_model2)

• We can see that the model was able to predict most species correctly but makes most mistakes on Black-grass and Loose Silky-bent. This might be because both are actually types of grass and the model is unable to disambaguate the patterns for these. Some more data collection/augmentation for these classes or using additional features or a separate model for these might help boost the final accuracy further.

scores_nn(cnn_model2)

Train: 81.27%
Test:  80.50%

• Final Accuracies:

Model	Training Accuracy	Testing Accuracy
Naive Bayes Classifier	30.86%	22.15%
SGD Classifier	95.80%	39.26%
KNN Classifier	58.00%	46.81%
Neural Net	66.87%	60.06%
CNN	87.83%	69.39%
CNN + Data Augmentation	81.27%	80.50%

• Pickle the best model for future use: Clearly, The final CNN Model is the best model and was able to acheive a n out-of-sample testing accuracy of 80.5%.

best_model = cnn_model2
filename = 'Seedling_Species_Classifier'
best_model.save(f"{filename}.h5")

# some time later...

# load the model from disk
from tensorflow.keras.models import load_model
 
# load model
seedling_classifier = load_model(f"{filename}.h5")
# summarize model.
seedling_classifier.summary()
# Hence, this model can be loaded and re-used anywhere with similar datasets

Model: "sequential_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_12 (Conv2D)           (None, 252, 252, 64)      1664      
_________________________________________________________________
batch_normalization_21 (Batc (None, 252, 252, 64)      256       
_________________________________________________________________
conv2d_13 (Conv2D)           (None, 248, 248, 64)      102464    
_________________________________________________________________
max_pooling2d_6 (MaxPooling2 (None, 124, 124, 64)      0         
_________________________________________________________________
batch_normalization_22 (Batc (None, 124, 124, 64)      256       
_________________________________________________________________
dropout_15 (Dropout)         (None, 124, 124, 64)      0         
_________________________________________________________________
conv2d_14 (Conv2D)           (None, 120, 120, 128)     204928    
_________________________________________________________________
batch_normalization_23 (Batc (None, 120, 120, 128)     512       
_________________________________________________________________
conv2d_15 (Conv2D)           (None, 116, 116, 128)     409728    
_________________________________________________________________
max_pooling2d_7 (MaxPooling2 (None, 58, 58, 128)       0         
_________________________________________________________________
batch_normalization_24 (Batc (None, 58, 58, 128)       512       
_________________________________________________________________
dropout_16 (Dropout)         (None, 58, 58, 128)       0         
_________________________________________________________________
conv2d_16 (Conv2D)           (None, 54, 54, 256)       819456    
_________________________________________________________________
batch_normalization_25 (Batc (None, 54, 54, 256)       1024      
_________________________________________________________________
conv2d_17 (Conv2D)           (None, 50, 50, 256)       1638656   
_________________________________________________________________
max_pooling2d_8 (MaxPooling2 (None, 25, 25, 256)       0         
_________________________________________________________________
batch_normalization_26 (Batc (None, 25, 25, 256)       1024      
_________________________________________________________________
dropout_17 (Dropout)         (None, 25, 25, 256)       0         
_________________________________________________________________
flatten_3 (Flatten)          (None, 160000)            0         
_________________________________________________________________
dense_12 (Dense)             (None, 512)               81920512  
_________________________________________________________________
batch_normalization_27 (Batc (None, 512)               2048      
_________________________________________________________________
dropout_18 (Dropout)         (None, 512)               0         
_________________________________________________________________
dense_13 (Dense)             (None, 512)               262656    
_________________________________________________________________
batch_normalization_28 (Batc (None, 512)               2048      
_________________________________________________________________
dropout_19 (Dropout)         (None, 512)               0         
_________________________________________________________________
dense_14 (Dense)             (None, 12)                6156      
=================================================================
Total params: 85,373,900
Trainable params: 85,370,060
Non-trainable params: 3,840
_________________________________________________________________

img_path = Path('./data/Seedling - Prediction/Predict.png')
test_img = imread(img_path)

display(test_img, label='')

Shape: (578, 578, 3)

CODES_LABELS = {v: i for i, v in LABELS_CODES.items()}

CODES_LABELS

{0: 'Black-grass',
 1: 'Charlock',
 2: 'Cleavers',
 3: 'Common Chickweed',
 4: 'Common wheat',
 5: 'Fat Hen',
 6: 'Loose Silky-bent',
 7: 'Maize',
 8: 'Scentless Mayweed',
 9: 'Shepherds Purse',
 10: 'Small-flowered Cranesbill',
 11: 'Sugar beet'}

# predict
def predict_seedling(image, model=seedling_classifier, labels=CODES_LABELS, actual=''):
    display(image, label='Input')
    # preprocess
    image_preprocessed = preprocess(image)
    # reshape to 256x256
    image_reshaped = img_reshape(image_preprocessed)
    display(image_reshaped, label='Reshaped')
    # reshape the input tensor to 1x256z256x1 to make it compatible with mdoel format
    model_input = image_reshaped.reshape(
        [1, image_reshaped.shape[0], image_reshaped.shape[1], 1])
    # predict 
    softamx_output = seedling_classifier(model_input)
    # convert to hardmax using np.argmax
    code = np.argmax(softamx_output)
    # get label
    pred_label = labels.get(code)
    # display final prediction
    if actual:
        display(image, label=f'Predicted: {pred_label} | Actual: {actual}')
    else:
        display(image, label=f'Predicted: {pred_label}')

predict_seedling(test_img)

Shape: (578, 578, 3)

Shape: (256, 256)

Shape: (578, 578, 3)

# test on a few random sample images from each species
images = list()
labels = list()
for sp in species:
    # get random images for each species
    for i in range(1):
        images.append(random.choice(species[sp]))
        labels.append(sp)

for test_img, label in zip(images, labels):
    predict_seedling(test_img, actual=label)

Shape: (603, 603, 3)

Shape: (256, 256)

Shape: (603, 603, 3)

Shape: (422, 422, 3)

Shape: (256, 256)

Shape: (422, 422, 3)

Shape: (357, 357, 3)

Shape: (256, 256)

Shape: (357, 357, 3)

Shape: (521, 521, 3)

Shape: (256, 256)

Shape: (521, 521, 3)

Shape: (106, 106, 3)

Shape: (256, 256)

Shape: (106, 106, 3)

Shape: (678, 678, 3)

Shape: (256, 256)

Shape: (678, 678, 3)

Shape: (758, 767, 3)

Shape: (256, 256)

Shape: (758, 767, 3)

Shape: (564, 564, 3)

Shape: (256, 256)

Shape: (564, 564, 3)

Shape: (140, 140, 3)

Shape: (256, 256)

Shape: (140, 140, 3)

Shape: (441, 441, 3)

Shape: (256, 256)

Shape: (441, 441, 3)

Shape: (387, 387, 3)

Shape: (256, 256)

Shape: (387, 387, 3)

Shape: (493, 493, 3)

Shape: (256, 256)

Shape: (493, 493, 3)